/**
 * viewportService.js
 * 提供医学影像查看器的视口操作功能
 * 从ViewerPage.vue中提取，专注于图像显示、浏览和视图操作相关的功能
 */

import cornerstone from 'cornerstone-core';
import * as cornerstoneService from './cornerstoneService';

/**
 * 显示指定索引的图像
 * @param {string} imageId - 图像ID
 * @param {HTMLElement} viewportElement - 视口元素
 * @param {Object} options - 显示选项
 * @returns {Promise<Object>} 显示的图像对象
 */
export async function displayImage(imageId, viewportElement, options = {}) {
  if (!imageId || !viewportElement) {
    return {
      success: false,
      error: '无效的图像ID或视口元素'
    };
  }
  
  try {
    // 记录开始时间（用于性能监控）
    const startTime = performance.now();
    
    // 加载图像
    const image = await cornerstone.loadAndCacheImage(imageId);
    
    // 显示图像
    cornerstone.displayImage(viewportElement, image);
    
    // 记录耗时
    const displayTime = performance.now() - startTime;
    
    // 返回结果
    return {
      success: true,
      image: image,
      displayTime: displayTime
    };
  } catch (error) {
    console.error('显示图像失败:', error);
    return {
      success: false,
      error: error.message || '显示图像失败'
    };
  }
}

/**
 * 浏览到前一张或后一张图像
 * @param {string[]} imageIds - 图像ID数组
 * @param {number} currentIndex - 当前图像索引
 * @param {number} direction - 方向，1表示下一张，-1表示上一张
 * @returns {Object} 新的索引信息
 */
export function navigate(imageIds, currentIndex, direction) {
  if (!imageIds || imageIds.length === 0) {
    return {
      success: false,
      error: '无效的图像ID列表'
    };
  }
  
  // 计算新的索引
  const newIndex = Math.max(0, Math.min(imageIds.length - 1, currentIndex + direction));
  
  // 检查是否有变化
  const changed = newIndex !== currentIndex;
  
  return {
    success: true,
    index: newIndex,
    changed: changed,
    imageId: imageIds[newIndex],
    isFirst: newIndex === 0,
    isLast: newIndex === imageIds.length - 1
  };
}

/**
 * 跳转到指定索引的图像
 * @param {string[]} imageIds - 图像ID数组
 * @param {number} targetIndex - 目标图像索引
 * @returns {Object} 新的索引信息
 */
export function jumpToIndex(imageIds, targetIndex) {
  if (!imageIds || imageIds.length === 0) {
    return {
      success: false,
      error: '无效的图像ID列表'
    };
  }
  
  // 确保索引在有效范围内
  const validIndex = Math.max(0, Math.min(imageIds.length - 1, targetIndex));
  
  return {
    success: true,
    index: validIndex,
    imageId: imageIds[validIndex],
    isFirst: validIndex === 0,
    isLast: validIndex === imageIds.length - 1
  };
}

/**
 * 根据窗宽窗位调整显示的图像
 * @param {HTMLElement} viewportElement - 视口元素
 * @param {number} windowWidth - 窗宽
 * @param {number} windowCenter - 窗位
 * @returns {Object} 视口信息
 */
export function setWindowLevel(viewportElement, windowWidth, windowCenter) {
  if (!viewportElement) {
    return {
      success: false,
      error: '无效的视口元素'
    };
  }
  
  try {
    // 获取当前视口
    const viewport = cornerstone.getViewport(viewportElement);
    
    // 设置窗宽窗位
    viewport.voi.windowWidth = windowWidth;
    viewport.voi.windowCenter = windowCenter;
    
    // 更新视口
    cornerstone.setViewport(viewportElement, viewport);
    
    // 返回结果
    return {
      success: true,
      viewport: {
        windowWidth: viewport.voi.windowWidth,
        windowCenter: viewport.voi.windowCenter,
        scale: viewport.scale,
        invert: viewport.invert
      }
    };
  } catch (error) {
    console.error('设置窗宽窗位失败:', error);
    return {
      success: false,
      error: error.message || '设置窗宽窗位失败'
    };
  }
}

/**
 * 调整图像的窗宽窗位
 * @param {HTMLElement} viewportElement - 视口元素
 * @param {number} widthDelta - 窗宽调整量
 * @param {number} centerDelta - 窗位调整量
 * @returns {Object} 新的窗宽窗位
 */
export function adjustWindowLevel(viewportElement, widthDelta, centerDelta) {
  if (!viewportElement) {
    return {
      success: false,
      error: '无效的视口元素'
    };
  }
  
  try {
    // 获取当前视口
    const viewport = cornerstone.getViewport(viewportElement);
    
    // 调整窗宽窗位
    viewport.voi.windowWidth += widthDelta;
    viewport.voi.windowCenter += centerDelta;
    
    // 确保窗宽为正值
    if (viewport.voi.windowWidth < 1) {
      viewport.voi.windowWidth = 1;
    }
    
    // 更新视口
    cornerstone.setViewport(viewportElement, viewport);
    
    // 返回结果
    return {
      success: true,
      windowWidth: viewport.voi.windowWidth,
      windowCenter: viewport.voi.windowCenter
    };
  } catch (error) {
    console.error('调整窗宽窗位失败:', error);
    return {
      success: false,
      error: error.message || '调整窗宽窗位失败'
    };
  }
}

/**
 * 应用预设的窗宽窗位值
 * @param {HTMLElement} viewportElement - 视口元素
 * @param {string} preset - 预设名称
 * @returns {Object} 应用的窗宽窗位值
 */
export function applyWindowLevelPreset(viewportElement, preset) {
  // 定义常用预设
  const presets = {
    'default': { width: 400, center: 40 },
    'brain': { width: 80, center: 40 },
    'lung': { width: 1500, center: -500 },
    'bone': { width: 2500, center: 480 },
    'abdomen': { width: 400, center: 50 },
    'mediastinum': { width: 350, center: 40 },
    'spine': { width: 500, center: 30 }
  };
  
  // 获取预设值
  const presetValues = presets[preset] || presets.default;
  
  // 应用预设值
  return setWindowLevel(viewportElement, presetValues.width, presetValues.center);
}

/**
 * 从图像元数据中获取窗宽窗位
 * @param {Object} image - Cornerstone图像对象
 * @param {string} preset - 预设名称，可选
 * @returns {Object} 窗宽窗位值
 */
export function getWindowLevelFromImage(image, preset = null) {
  if (!image) {
    return {
      success: false,
      error: '无效的图像对象'
    };
  }
  
  try {
    // 如果指定了预设，使用预设值
    if (preset) {
      return applyWindowLevelPreset(null, preset);
    }
    
    // 从图像元数据获取窗宽窗位
    let windowWidth = image.windowWidth || 400;
    let windowCenter = image.windowCenter || 40;
    
    // 如果是数组，取第一个值
    if (Array.isArray(windowWidth)) {
      windowWidth = windowWidth[0];
    }
    if (Array.isArray(windowCenter)) {
      windowCenter = windowCenter[0];
    }
    
    return {
      success: true,
      windowWidth: windowWidth,
      windowCenter: windowCenter
    };
  } catch (error) {
    console.error('获取图像窗宽窗位失败:', error);
    return {
      success: false,
      error: error.message || '获取图像窗宽窗位失败',
      windowWidth: 400,
      windowCenter: 40
    };
  }
}

/**
 * 获取图像元数据
 * @param {HTMLElement} viewportElement - 视口元素
 * @returns {Object} 图像元数据
 */
export function getImageMetadata(viewportElement) {
  if (!viewportElement) {
    return {
      success: false,
      error: '无效的视口元素'
    };
  }
  
  try {
    // 获取显示的图像
    const image = cornerstone.getImage(viewportElement);
    
    if (!image || !image.data) {
      return {
        success: false,
        error: '无图像数据'
      };
    }
    
    // 提取元数据
    const metadata = {
      modality: image.data.string('x00080060') || 'Unknown',
      seriesNumber: image.data.string('x00200011') || '',
      instanceNumber: image.data.string('x00200013') || '',
      thickness: image.data.string('x00180050') || '',
      position: image.data.string('x00201041') || '',
      sliceLocation: image.data.string('x00201041') || '',
      rows: image.rows,
      columns: image.columns,
      pixelSpacing: {
        row: image.rowPixelSpacing || 1,
        column: image.columnPixelSpacing || 1
      }
    };
    
    return {
      success: true,
      metadata: metadata,
      image: image
    };
  } catch (error) {
    console.error('获取图像元数据失败:', error);
    return {
      success: false,
      error: error.message || '获取图像元数据失败'
    };
  }
}

/**
 * 缓存当前视图状态
 * @param {HTMLElement} viewportElement - 视口元素
 * @param {string} imageId - 图像ID
 * @returns {Object} 缓存的视图状态
 */
const viewStateCache = new Map();

export function cacheViewState(viewportElement, imageId) {
  if (!viewportElement || !imageId) {
    return {
      success: false,
      error: '无效的视口元素或图像ID'
    };
  }
  
  try {
    // 获取当前视口状态
    const viewport = cornerstone.getViewport(viewportElement);
    
    // 缓存视口状态
    viewStateCache.set(imageId, {
      viewport: {
        scale: viewport.scale,
        translation: { ...viewport.translation },
        voi: { ...viewport.voi },
        invert: viewport.invert,
        rotation: viewport.rotation
      },
      timestamp: Date.now()
    });
    
    return {
      success: true,
      imageId: imageId,
      viewport: viewport
    };
  } catch (error) {
    console.error('缓存视图状态失败:', error);
    return {
      success: false,
      error: error.message || '缓存视图状态失败'
    };
  }
}

/**
 * 应用缓存的视图状态
 * @param {HTMLElement} viewportElement - 视口元素
 * @param {string} imageId - 图像ID
 * @returns {Object} 应用结果
 */
export function applyViewState(viewportElement, imageId) {
  if (!viewportElement || !imageId) {
    return {
      success: false,
      error: '无效的视口元素或图像ID'
    };
  }
  
  try {
    // 获取缓存的视口状态
    const cachedState = viewStateCache.get(imageId);
    
    if (!cachedState) {
      return {
        success: false,
        error: '未找到缓存的视图状态'
      };
    }
    
    // 应用缓存的视口状态
    cornerstone.setViewport(viewportElement, cachedState.viewport);
    
    return {
      success: true,
      imageId: imageId,
      viewport: cachedState.viewport,
      timestamp: cachedState.timestamp
    };
  } catch (error) {
    console.error('应用视图状态失败:', error);
    return {
      success: false,
      error: error.message || '应用视图状态失败'
    };
  }
}

/**
 * 清理视图状态缓存
 * @param {string} imageId - 特定图像ID，如果未指定则清除所有缓存
 * @returns {boolean} 成功返回true，失败返回false
 */
export function clearViewStateCache(imageId = null) {
  try {
    if (imageId) {
      // 清除特定图像的缓存
      viewStateCache.delete(imageId);
    } else {
      // 清除所有缓存
      viewStateCache.clear();
    }
    return true;
  } catch (error) {
    console.error('清理视图状态缓存失败:', error);
    return false;
  }
}

/**
 * 计算图像尺寸和缩放比例
 * @param {HTMLElement} viewportElement - 视口元素
 * @param {Object} image - Cornerstone图像对象
 * @returns {Object} 尺寸和缩放信息
 */
export function calculateImageDimensions(viewportElement, image) {
  if (!viewportElement || !image) {
    return {
      success: false,
      error: '无效的视口元素或图像'
    };
  }
  
  try {
    const viewport = cornerstone.getViewport(viewportElement);
    
    // 计算图像尺寸
    const imageWidth = image.columns;
    const imageHeight = image.rows;
    
    // 计算视口尺寸
    const viewportWidth = viewportElement.clientWidth;
    const viewportHeight = viewportElement.clientHeight;
    
    // 计算显示比例
    const displayRatio = {
      x: (imageWidth * viewport.scale) / viewportWidth,
      y: (imageHeight * viewport.scale) / viewportHeight
    };
    
    return {
      success: true,
      image: {
        width: imageWidth,
        height: imageHeight
      },
      viewport: {
        width: viewportWidth,
        height: viewportHeight
      },
      scale: viewport.scale,
      displayRatio: displayRatio
    };
  } catch (error) {
    console.error('计算图像尺寸失败:', error);
    return {
      success: false,
      error: error.message || '计算图像尺寸失败'
    };
  }
}

/**
 * 将屏幕坐标转换为图像坐标
 * @param {HTMLElement} viewportElement - 视口元素
 * @param {Object} clientPoint - 屏幕坐标点 {x, y}
 * @returns {Object} 图像坐标点
 */
export function clientToImageCoords(viewportElement, clientPoint) {
  if (!viewportElement || !clientPoint) {
    return {
      success: false,
      error: '无效的视口元素或坐标点'
    };
  }
  
  try {
    // 获取元素在页面中的位置
    const rect = viewportElement.getBoundingClientRect();
    
    // 计算相对于元素的坐标
    const point = {
      x: clientPoint.x - rect.left,
      y: clientPoint.y - rect.top
    };
    
    // 转换为图像坐标
    const imagePoint = cornerstone.pageToPixel(viewportElement, point.x, point.y);
    
    return {
      success: true,
      imagePoint: imagePoint,
      clientPoint: clientPoint,
      elementPoint: point
    };
  } catch (error) {
    console.error('坐标转换失败:', error);
    return {
      success: false,
      error: error.message || '坐标转换失败'
    };
  }
} 